home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Text⁄Files / Tape Stuff / file.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-28  |  6.4 KB  |  281 lines  |  [TEXT/KAHL]
  1. /* file .c - handles the file activity */
  2.  
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <assert.h>
  6. #include "SCSIDefines.h"
  7. #include "pstring.h"
  8.  
  9. #include "Defines.h"
  10. #include "Prototypes.h"
  11.  
  12. extern BUFFER    *gBufferPtr;
  13. extern Str255    gParentDir;
  14.  
  15. short WriteEOF(void)
  16. {
  17.     char buffer[BLOCKSIZE];
  18.     
  19.     memset(buffer, 0, BLOCKSIZE);
  20.     if (BufferWrite(gBufferPtr, buffer, BLOCKSIZE) == ERROR) return ERROR;
  21.     return OK;
  22. }
  23.  
  24. short WriteFile(Str255 name)
  25. {
  26.     CInfoPBRec    paramBlock;            /* parameter block                     */
  27.     OSErr error;                    /* error status                     */
  28.     FInfo info;                        /* finder information                 */
  29.     HEADER header;                    /* file header                         */
  30.     short refNum;                    /* file path reference number         */
  31.     char buffer[BLOCKSIZE];            /* data buffer                         */
  32.     long i;                            /* counter                            */
  33.     long bytesLeft;                    /* number of bytes in last block    */
  34.     long count = BLOCKSIZE;            /* number of bytes read             */
  35.  
  36.     /* get file parameters */
  37.  
  38.     memset(¶mBlock, 0, sizeof(paramBlock));
  39.     paramBlock.hFileInfo.ioNamePtr         =     name;
  40.     
  41.     error = PBGetCatInfo(¶mBlock, FALSE);
  42.     if (error != noErr) return ERROR;
  43.     
  44.     /* set up fields of header */
  45.     
  46.     assert(sizeof(HEADER) == BLOCKSIZE);
  47.     memset(&header, 0, sizeof(header));
  48.     header.name[0] = name[0] - gParentDir[0];
  49.     memcpy(&(header.name[1]), &(name[gParentDir[0] + 1]), name[0]);
  50.     if ((paramBlock.hFileInfo.ioFlAttrib & IOFADIRECTORY) == 0)
  51.     { 
  52.         header.directory         =     FALSE;
  53.         header.type             =     paramBlock.hFileInfo.ioFlFndrInfo.fdType;
  54.         header.creator             =     paramBlock.hFileInfo.ioFlFndrInfo.fdCreator;
  55.         header.dataLength        =    paramBlock.hFileInfo.ioFlLgLen;
  56.         header.rsrcLength        =    paramBlock.hFileInfo.ioFlRLgLen;
  57.     }
  58.     else 
  59.     {
  60.         printf("DIRECTORY!!!\n");
  61.         header.directory         =     TRUE;
  62.     }
  63.     header.creationDate            =    paramBlock.hFileInfo.ioFlCrDat;
  64.     header.modificationDate        =    paramBlock.hFileInfo.ioFlMdDat;
  65.     header.checksum                =     Checksum(&header, sizeof(header) - sizeof(header.checksum));
  66.     
  67.     /* write header */
  68.     
  69.     memset(buffer, 0, BLOCKSIZE);
  70.     memcpy(buffer, &header, sizeof(header));
  71.     if (BufferWrite(gBufferPtr, buffer, BLOCKSIZE) == ERROR) return ERROR;
  72.     
  73.     printf("%s\n", PtoCstr(header.name));
  74.     if (header.directory == TRUE) return OK;
  75.     
  76.     /* now write data: shouldn't be any errors so no checking is done! */
  77.     
  78.     /* Resource fork */
  79.     
  80.     if (header.rsrcLength)
  81.     {
  82.         OpenRF(name, 0, &refNum);
  83.     
  84.         for (i = 0; i < (header.rsrcLength - BLOCKSIZE); i += BLOCKSIZE)
  85.         {
  86.             FSRead(refNum, &count, buffer);
  87.             BufferWrite(gBufferPtr, buffer, BLOCKSIZE);
  88.         }
  89.         bytesLeft = header.rsrcLength - i;
  90.         if (bytesLeft > 0)
  91.         {
  92.             memset(buffer, 0, BLOCKSIZE);
  93.             FSRead(refNum, &bytesLeft, buffer);
  94.             BufferWrite(gBufferPtr, buffer, BLOCKSIZE);
  95.         }
  96.     
  97.         FSClose(refNum);
  98.     }
  99.     
  100.     /* Data fork */
  101.     
  102.     if (header.dataLength)
  103.     {
  104.         FSOpen(name, 0, &refNum);
  105.     
  106.         for (i = 0; i < (header.dataLength - BLOCKSIZE); i += BLOCKSIZE)
  107.         {
  108.             FSRead(refNum, &count, buffer);
  109.             BufferWrite(gBufferPtr, buffer, BLOCKSIZE);
  110.         }
  111.         bytesLeft = header.dataLength - i;
  112.         if (bytesLeft > 0)
  113.         {
  114.             memset(buffer, 0, BLOCKSIZE);
  115.             FSRead(refNum, &bytesLeft, buffer);
  116.             BufferWrite(gBufferPtr, buffer, BLOCKSIZE);
  117.         }
  118.     
  119.         FSClose(refNum);
  120.     }
  121.     
  122.     return OK;
  123. }
  124.  
  125. short ReadFile(void)
  126. {
  127.     HEADER header;                    /* file header                         */
  128.     short refNum;                    /* file path reference number         */
  129.     char buffer[BLOCKSIZE];            /* data buffer                         */
  130.     long i;                            /* counter                            */
  131.     long bytesLeft;                    /* number of bytes in last block    */
  132.     long count = BLOCKSIZE;            /* number of bytes read             */
  133.     OSErr error;                    /* error return                     */
  134.     HParamBlockRec pb;                /* parameter block                     */
  135.     Str255 name;                    /* reassembled filename                */
  136.  
  137.     /* read header */
  138.     
  139.     if (BufferRead(gBufferPtr, buffer, BLOCKSIZE) == ERROR) return ERROR;
  140.     memcpy(&header, buffer, sizeof(header));
  141.     
  142.     /* check checksum */
  143.     
  144.     if (Checksum(&header, sizeof(header) - sizeof(header.checksum)) != header.checksum)
  145.         return ERROR;
  146.         
  147.     if (header.checksum == 0) return FILE_END;
  148.  
  149.     Pstrcpy(name, gParentDir);
  150.     Pstrcat(name, header.name);
  151.     printf("%s\n",PtoCstr(header.name));
  152.     
  153.     if (header.directory == TRUE)
  154.     {
  155.         memset(&pb, 0, sizeof(pb));
  156.         pb.fileParam.ioNamePtr = name;
  157.         error = PBDirCreate(&pb, FALSE);
  158.         return OK;
  159.     }    
  160.     
  161.     /* now read data */
  162.     
  163.     error = Create(name, 0, header.creator, header.type);
  164.     if (error != noErr) return ERROR;
  165.     
  166.     /* Resource fork */
  167.     
  168.     if (header.rsrcLength)
  169.     {
  170.         OpenRF(name, 0, &refNum);
  171.     
  172.         for (i = 0; i < (header.rsrcLength - BLOCKSIZE); i += BLOCKSIZE)
  173.         {
  174.             BufferRead(gBufferPtr, buffer, BLOCKSIZE);
  175.             FSWrite(refNum, &count, buffer);
  176.         }
  177.         bytesLeft = header.rsrcLength - i;
  178.         if (bytesLeft > 0)
  179.         {
  180.             BufferRead(gBufferPtr, buffer, BLOCKSIZE);
  181.             FSWrite(refNum, &bytesLeft, buffer);
  182.         }
  183.     
  184.         FSClose(refNum);
  185.     }
  186.     
  187.     /* Data fork */
  188.     
  189.     if (header.dataLength)
  190.     {
  191.         FSOpen(name, 0, &refNum);
  192.     
  193.         for (i = 0; i < (header.dataLength - BLOCKSIZE); i += BLOCKSIZE)
  194.         {
  195.             BufferRead(gBufferPtr, buffer, BLOCKSIZE);
  196.             FSWrite(refNum, &count, buffer);
  197.         }
  198.         bytesLeft = header.dataLength - i;
  199.         if (bytesLeft > 0)
  200.         {
  201.             BufferRead(gBufferPtr, buffer, BLOCKSIZE);
  202.             FSWrite(refNum, &bytesLeft, buffer);
  203.         }
  204.     
  205.         FSClose(refNum);
  206.     }
  207.     
  208.     return OK;
  209. }
  210.  
  211. short ListFile(void)
  212. {
  213.     HEADER header;                    /* file header                         */
  214.     short refNum;                    /* file path reference number         */
  215.     char buffer[BLOCKSIZE];            /* data buffer                         */
  216.     long i;                            /* counter                            */
  217.     long bytesLeft;                    /* number of bytes in last block    */
  218.     long count = BLOCKSIZE;            /* number of bytes read             */
  219.     OSErr error;                    /* eror return                         */
  220.  
  221.     /* read header */
  222.     
  223.     if (BufferRead(gBufferPtr, buffer, BLOCKSIZE) == ERROR) return ERROR;
  224.     memcpy(&header, buffer, sizeof(header));
  225.     
  226.     /* check checksum */
  227.     
  228.     if (Checksum(&header, sizeof(header) - sizeof(header.checksum)) != header.checksum)
  229.         return ERROR;
  230.         
  231.     if (header.checksum == 0) return FILE_END;
  232.     
  233.     printf("%s\n",PtoCstr(header.name));
  234.     
  235.     /* now read data */
  236.         
  237.     /* Resource fork */
  238.         
  239.     for (i = 0; i < (header.rsrcLength - BLOCKSIZE); i += BLOCKSIZE)
  240.     {
  241.         BufferRead(gBufferPtr, buffer, BLOCKSIZE);
  242.     }
  243.     bytesLeft = header.rsrcLength - i;
  244.     if (bytesLeft > 0)
  245.     {
  246.         BufferRead(gBufferPtr, buffer, BLOCKSIZE);
  247.     }
  248.     
  249.     /* Data fork */
  250.     
  251.     for (i = 0; i < (header.dataLength - BLOCKSIZE); i += BLOCKSIZE)
  252.     {
  253.         BufferRead(gBufferPtr, buffer, BLOCKSIZE);
  254.     }
  255.     bytesLeft = header.dataLength - i;
  256.     if (bytesLeft > 0)
  257.     {
  258.         BufferRead(gBufferPtr, buffer, BLOCKSIZE);
  259.     }
  260.     
  261.     return OK;
  262. }
  263.     
  264. long Checksum(void *bufferPtr, long count)
  265. {
  266.     long i;
  267.     long sum = 0;
  268.     char *ptr;
  269.     
  270.     ptr = (char *)bufferPtr;
  271.     for (i = 0; i < count; i++)
  272.     {
  273.         sum += *ptr;
  274.         ptr++;
  275.     }
  276.     
  277.     return sum;
  278. }
  279.  
  280.  
  281.